Language/OS - Multiplatform Resource Library/LANGUAGE OS.iso/ast_comp/ora-sql.shr

Text File | 1993-07-04 | 15KB | 850 lines

#!/bin/sh
#
# This is a SQL lexer and parser based on the grammar in Date's SQL
# book.  For more info, see Levine, Mason, and Brown, "lex&yacc," 2nd
# edition, O'Reilly and Associates, where this parser is explained in
# detail in Chapter 5.
#
# I grant anyone permission to reproduce these files in any form.  If
# you use it in a commercial product, I'd appreciate credit.
#
# John Levine, [e-mail], October 1992
#
# This is a shell archive (produced by shar 3.49)
# To extract the files from this archive, save it to a file, remove
# everything above the "!/bin/sh" line above, and type "sh file_name".
#
# made 10/31/1992 03:58 UTC by johnl@iecc
# Source directory /usr/johnl/nuts/lyref/code
#
# existing files will NOT be overwritten unless -c is specified
#
# This shar contains:
# length  mode       name
# ------ ---------- ------------------------------------------
#   9260 -rw-rw-r-- sql1.y
#   3533 -rw-rw-r-- scn1.l
#
# ============= sql1.y ==============
if test -f 'sql1.y' -a X"$1" != X"-c"; then
    echo 'x - skipping sql1.y (File already exists)'
else
echo 'x - extracting sql1.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'sql1.y' &&
X    /* symbolic tokens */
X
%union {
X    int intval;
X    double floatval;
X    char *strval;
X    int subtok;
}
X
%token NAME
%token STRING
%token INTNUM APPROXNUM
X
X    /* operators */
X
%left OR
%left AND
%left NOT
%left <subtok> COMPARISON /* = <> < > <= >= */
%left '+' '-'
%left '*' '/'
%nonassoc UMINUS
X
X    /* literal keyword tokens */
X
%token ALL AMMSC ANY AS ASC AUTHORIZATION BETWEEN BY
%token CHARACTER CHECK CLOSE COMMIT CONTINUE CREATE CURRENT
%token CURSOR DECIMAL DECLARE DEFAULT DELETE DESC DISTINCT DOUBLE
%token ESCAPE EXISTS FETCH FLOAT FOR FOREIGN FOUND FROM GOTO
%token GRANT GROUP HAVING IN INDICATOR INSERT INTEGER INTO
%token IS KEY LANGUAGE LIKE MODULE NULLX NUMERIC OF ON
%token OPEN OPTION ORDER PRECISION PRIMARY PRIVILEGES PROCEDURE
%token PUBLIC REAL REFERENCES ROLLBACK SCHEMA SELECT SET
%token SMALLINT SOME SQLCODE SQLERROR TABLE TO UNION
%token UNIQUE UPDATE USER VALUES VIEW WHENEVER WHERE WITH WORK
%token COBOL FORTRAN PASCAL PLI C ADA
X
%%
X
sql_list:
X        sql ';'
X    |    sql_list sql ';'
X    ;
X
X
X    /* schema definition language */
X    /* Note: other ``sql:'' rules appear later in the grammar */
sql:        schema
X    ;
X
schema:
X        CREATE SCHEMA AUTHORIZATION user opt_schema_element_list
X    ;
X
opt_schema_element_list:
X        /* empty */
X    |    schema_element_list
X    ;
X
schema_element_list:
X        schema_element
X    |    schema_element_list schema_element
X    ;
X
schema_element:
X        base_table_def
X    |    view_def
X    |    privilege_def
X    ;
X
base_table_def:
X        CREATE TABLE table '(' base_table_element_commalist ')'
X    ;
X
base_table_element_commalist:
X        base_table_element
X    |    base_table_element_commalist ',' base_table_element
X    ;
X
base_table_element:
X        column_def
X    |    table_constraint_def
X    ;
X
column_def:
X        column data_type column_def_opt_list
X    ;
X
column_def_opt_list:
X        /* empty */
X    |    column_def_opt_list column_def_opt
X    ;
X
column_def_opt:
X        NOT NULLX
X    |    NOT NULLX UNIQUE
X    |    NOT NULLX PRIMARY KEY
X    |    DEFAULT literal
X    |    DEFAULT NULLX
X    |    DEFAULT USER
X    |    CHECK '(' search_condition ')'
X    |    REFERENCES table
X    |    REFERENCES table '(' column_commalist ')'
X    ;
X
table_constraint_def:
X        UNIQUE '(' column_commalist ')'
X    |    PRIMARY KEY '(' column_commalist ')'
X    |    FOREIGN KEY '(' column_commalist ')'
X            REFERENCES table
X    |    FOREIGN KEY '(' column_commalist ')'
X            REFERENCES table '(' column_commalist ')'
X    |    CHECK '(' search_condition ')'
X    ;
X
column_commalist:
X        column
X    |    column_commalist ',' column
X    ;
X
view_def:
X        CREATE VIEW table opt_column_commalist
X        AS query_spec opt_with_check_option
X    ;
X
opt_with_check_option:
X        /* empty */
X    |    WITH CHECK OPTION
X    ;
X
opt_column_commalist:
X        /* empty */
X    |    '(' column_commalist ')'
X    ;
X
privilege_def:
X        GRANT privileges ON table TO grantee_commalist
X        opt_with_grant_option
X    ;
X
opt_with_grant_option:
X        /* empty */
X    |    WITH GRANT OPTION
X    ;
X
privileges:
X        ALL PRIVILEGES
X    |    ALL
X    |    operation_commalist
X    ;
X
operation_commalist:
X        operation
X    |    operation_commalist ',' operation
X    ;
X
operation:
X        SELECT
X    |    INSERT
X    |    DELETE
X    |    UPDATE opt_column_commalist
X    |    REFERENCES opt_column_commalist
X    ;
X
X
grantee_commalist:
X        grantee
X    |    grantee_commalist ',' grantee
X    ;
X
grantee:
X        PUBLIC
X    |    user
X    ;
X
X    /* module language */
sql:        module_def
X    ;
X
module_def:
X        MODULE opt_module
X        LANGUAGE lang
X        AUTHORIZATION user
X        opt_cursor_def_list
X        procedure_def_list
X    ;
X
opt_module:
X        /* empty */
X    |    module
X    ;
X
lang:
X        COBOL
X    |    FORTRAN
X    |    PASCAL
X    |    PLI
X    |    C
X    |    ADA
X    ;
X
opt_cursor_def_list:
X        /* empty */
X    |    cursor_def_list
X    ;
X
cursor_def_list:
X        cursor_def
X    |    cursor_def_list cursor_def
X    ;
X
cursor_def:
X        DECLARE cursor CURSOR FOR query_exp opt_order_by_clause
X    ;
X
opt_order_by_clause:
X        /* empty */
X    |    ORDER BY ordering_spec_commalist
X    ;
X
ordering_spec_commalist:
X        ordering_spec
X    |    ordering_spec_commalist ',' ordering_spec
X    ;
X
ordering_spec:
X        INTNUM opt_asc_desc
X    |    column_ref opt_asc_desc
X    ;
X
opt_asc_desc:
X        /* empty */
X    |    ASC
X    |    DESC
X    ;
X
procedure_def_list:
X        procedure_def
X    |    procedure_def_list procedure_def
X    ;
X
procedure_def:
X        PROCEDURE procedure parameter_def_list ';'
X        manipulative_statement_list
X    ;
X
manipulative_statement_list:
X        manipulative_statement
X    |    manipulative_statement_list manipulative_statement
X    ;
X
parameter_def_list:
X        parameter_def
X    |    parameter_def_list parameter_def
X    ;
X
parameter_def:
X        parameter data_type
X    |    SQLCODE
X    ;
X
X    /* manipulative statements */
X
sql:        manipulative_statement
X    ;
X
manipulative_statement:
X        close_statement
X    |    commit_statement
X    |    delete_statement_positioned
X    |    delete_statement_searched
X    |    fetch_statement
X    |    insert_statement
X    |    open_statement
X    |    rollback_statement
X    |    select_statement
X    |    update_statement_positioned
X    |    update_statement_searched
X    ;
X
close_statement:
X        CLOSE cursor
X    ;
X
commit_statement:
X        COMMIT WORK
X    ;
X
delete_statement_positioned:
X        DELETE FROM table WHERE CURRENT OF cursor
X    ;
X
delete_statement_searched:
X        DELETE FROM table opt_where_clause
X    ;
X
fetch_statement:
X        FETCH cursor INTO target_commalist
X    ;
X
insert_statement:
X        INSERT INTO table opt_column_commalist values_or_query_spec
X    ;
X
values_or_query_spec:
X        VALUES '(' insert_atom_commalist ')'
X    |    query_spec
X    ;
X
insert_atom_commalist:
X        insert_atom
X    |    insert_atom_commalist ',' insert_atom
X    ;
X
insert_atom:
X        atom
X    |    NULLX
X    ;
X
open_statement:
X        OPEN cursor
X    ;
X
rollback_statement:
X        ROLLBACK WORK
X    ;
X
select_statement:
X        SELECT opt_all_distinct selection
X        INTO target_commalist
X        table_exp
X    ;
X
opt_all_distinct:
X        /* empty */
X    |    ALL
X    |    DISTINCT
X    ;
X
update_statement_positioned:
X        UPDATE table SET assignment_commalist
X        WHERE CURRENT OF cursor
X    ;
X
assignment_commalist:
X    |    assignment
X    |    assignment_commalist ',' assignment
X    ;
X
assignment:
X        column '=' scalar_exp
X    |    column '=' NULLX
X    ;
X
update_statement_searched:
X        UPDATE table SET assignment_commalist opt_where_clause
X    ;
X
target_commalist:
X        target
X    |    target_commalist ',' target
X    ;
X
target:
X        parameter_ref
X    ;
X
opt_where_clause:
X        /* empty */
X    |    where_clause
X    ;
X
X    /* query expressions */
X
query_exp:
X        query_term
X    |    query_exp UNION query_term
X    |    query_exp UNION ALL query_term
X    ;
X
query_term:
X        query_spec
X    |    '(' query_exp ')'
X    ;
X
query_spec:
X        SELECT opt_all_distinct selection table_exp
X    ;
X
selection:
X        scalar_exp_commalist
X    |    '*'
X    ;
X
table_exp:
X        from_clause
X        opt_where_clause
X        opt_group_by_clause
X        opt_having_clause
X    ;
X
from_clause:
X        FROM table_ref_commalist
X    ;
X
table_ref_commalist:
X        table_ref
X    |    table_ref_commalist ',' table_ref
X    ;
X
table_ref:
X        table
X    |    table range_variable
X    ;
X
where_clause:
X        WHERE search_condition
X    ;
X
opt_group_by_clause:
X        /* empty */
X    |    GROUP BY column_ref_commalist
X    ;
X
column_ref_commalist:
X        column_ref
X    |    column_ref_commalist ',' column_ref
X    ;
X
opt_having_clause:
X        /* empty */
X    |    HAVING search_condition
X    ;
X
X    /* search conditions */
X
search_condition:
X    |    search_condition OR search_condition
X    |    search_condition AND search_condition
X    |    NOT search_condition
X    |    '(' search_condition ')'
X    |    predicate
X    ;
X
predicate:
X        comparison_predicate
X    |    between_predicate
X    |    like_predicate
X    |    test_for_null
X    |    in_predicate
X    |    all_or_any_predicate
X    |    existence_test
X    ;
X
comparison_predicate:
X        scalar_exp COMPARISON scalar_exp
X    |    scalar_exp COMPARISON subquery
X    ;
X
between_predicate:
X        scalar_exp NOT BETWEEN scalar_exp AND scalar_exp
X    |    scalar_exp BETWEEN scalar_exp AND scalar_exp
X    ;
X
like_predicate:
X        scalar_exp NOT LIKE atom opt_escape
X    |    scalar_exp LIKE atom opt_escape
X    ;
X
opt_escape:
X        /* empty */
X    |    ESCAPE atom
X    ;
X
test_for_null:
X        column_ref IS NOT NULLX
X    |    column_ref IS NULLX
X    ;
X
in_predicate:
X        scalar_exp NOT IN '(' subquery ')'
X    |    scalar_exp IN '(' subquery ')'
X    |    scalar_exp NOT IN '(' atom_commalist ')'
X    |    scalar_exp IN '(' atom_commalist ')'
X    ;
X
atom_commalist:
X        atom
X    |    atom_commalist ',' atom
X    ;
X
all_or_any_predicate:
X        scalar_exp COMPARISON any_all_some subquery
X    ;
X
any_all_some:
X        ANY
X    |    ALL
X    |    SOME
X    ;
X
existence_test:
X        EXISTS subquery
X    ;
X
subquery:
X        '(' SELECT opt_all_distinct selection table_exp ')'
X    ;
X
X    /* scalar expressions */
X
scalar_exp:
X        scalar_exp '+' scalar_exp
X    |    scalar_exp '-' scalar_exp
X    |    scalar_exp '*' scalar_exp
X    |    scalar_exp '/' scalar_exp
X    |    '+' scalar_exp %prec UMINUS
X    |    '-' scalar_exp %prec UMINUS
X    |    atom
X    |    column_ref
X    |    function_ref
X    |    '(' scalar_exp ')'
X    ;
X
scalar_exp_commalist:
X        scalar_exp
X    |    scalar_exp_commalist ',' scalar_exp
X    ;
X
atom:
X        parameter_ref
X    |    literal
X    |    USER
X    ;
X
parameter_ref:
X        parameter
X    |    parameter parameter
X    |    parameter INDICATOR parameter
X    ;
X
function_ref:
X        AMMSC '(' '*' ')'
X    |    AMMSC '(' DISTINCT column_ref ')'
X    |    AMMSC '(' ALL scalar_exp ')'
X    |    AMMSC '(' scalar_exp ')'
X    ;
X
literal:
X        STRING
X    |    INTNUM
X    |    APPROXNUM
X    ;
X
X    /* miscellaneous */
X
table:
X        NAME
X    |    NAME '.' NAME
X    ;
X
column_ref:
X        NAME
X    |    NAME '.' NAME    /* needs semantics */
X    |    NAME '.' NAME '.' NAME
X    ;
X
X        /* data types */
X
data_type:
X        CHARACTER
X    |    CHARACTER '(' INTNUM ')'
X    |    NUMERIC
X    |    NUMERIC '(' INTNUM ')'
X    |    NUMERIC '(' INTNUM ',' INTNUM ')'
X    |    DECIMAL
X    |    DECIMAL '(' INTNUM ')'
X    |    DECIMAL '(' INTNUM ',' INTNUM ')'
X    |    INTEGER
X    |    SMALLINT
X    |    FLOAT
X    |    FLOAT '(' INTNUM ')'
X    |    REAL
X    |    DOUBLE PRECISION
X    ;
X
X    /* the various things you can name */
X
column:        NAME
X    ;
X
cursor:        NAME
X    ;
X
module:        NAME
X    ;
X
parameter:
X        ':' NAME
X    ;
X
procedure:    NAME
X    ;
X
range_variable:    NAME
X    ;
X
user:        NAME
X    ;
X
X    /* embedded condition things */
sql:        WHENEVER NOT FOUND when_action
X    |    WHENEVER SQLERROR when_action
X    ;
X
when_action:    GOTO NAME
X    |    CONTINUE
X    ;
%%
SHAR_EOF
chmod 0664 sql1.y ||
echo 'restore of sql1.y failed'
Wc_c="`wc -c < 'sql1.y'`"
test 9260 -eq "$Wc_c" ||
    echo 'sql1.y: original size 9260, current size' "$Wc_c"
fi
# ============= scn1.l ==============
if test -f 'scn1.l' -a X"$1" != X"-c"; then
    echo 'x - skipping scn1.l (File already exists)'
else
echo 'x - extracting scn1.l (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'scn1.l' &&
%{
/*
X * AT&T lex can't handle this lexer due to lex bugs.  It works with flex
X * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
X */
X
#include "sql1.h"
#include <string.h>
X
int lineno = 1;
void yyerror(char *s);
%}
X    /* MKS needs the next line to increase the NFA table */
%e 1200
X
%%
X
X    /* literal keyword tokens */
X
ADA        { return ADA; }
ALL        { return ALL; }
AND        { return AND; }
AVG        { return AMMSC; }
MIN        { return AMMSC; }
MAX        { return AMMSC; }
SUM        { return AMMSC; }
COUNT        { return AMMSC; }
ANY        { return ANY; }
AS        { return AS; }
ASC        { return ASC; }
AUTHORIZATION    { return AUTHORIZATION; }
BETWEEN        { return BETWEEN; }
BY        { return BY; }
C        { return C; }
CHAR(ACTER)?    { return CHARACTER; }
CHECK        { return CHECK; }
CLOSE        { return CLOSE; }
COBOL        { return COBOL; }
COMMIT        { return COMMIT; }
CONTINUE    { return CONTINUE; }
CREATE        { return CREATE; }
CURRENT        { return CURRENT; }
CURSOR        { return CURSOR; }
DECIMAL        { return DECIMAL; }
DECLARE        { return DECLARE; }
DEFAULT        { return DEFAULT; }
DELETE        { return DELETE; }
DESC        { return DESC; }
DISTINCT    { return DISTINCT; }
DOUBLE        { return DOUBLE; }
ESCAPE        { return ESCAPE; }
EXISTS        { return EXISTS; }
FETCH        { return FETCH; }
FLOAT        { return FLOAT; }
FOR        { return FOR; }
FOREIGN        { return FOREIGN; }
FORTRAN        { return FORTRAN; }
FOUND        { return FOUND; }
FROM        { return FROM; }
GO[ \t]*TO    { return GOTO; }
GRANT        { return GRANT; }
GROUP        { return GROUP; }
HAVING        { return HAVING; }
IN        { return IN; }
INDICATOR    { return INDICATOR; }
INSERT        { return INSERT; }
INT(EGER)?    { return INTEGER; }
INTO        { return INTO; }
IS        { return IS; }
KEY        { return KEY; }
LANGUAGE    { return LANGUAGE; }
LIKE        { return LIKE; }
MODULE        { return MODULE; }
NOT        { return NOT; }
NULL        { return NULLX; }
NUMERIC        { return NUMERIC; }
OF        { return OF; }
ON        { return ON; }
OPEN        { return OPEN; }
OPTION        { return OPTION; }
OR        { return OR; }
ORDER        { return ORDER; }
PASCAL        { return PASCAL; }
PLI        { return PLI; }
PRECISION    { return PRECISION; }
PRIMARY        { return PRIMARY; }
PRIVILEGES    { return PRIVILEGES; }
PROCEDURE    { return PROCEDURE; }
PUBLIC        { return PUBLIC; }
REAL        { return REAL; }
REFERENCES    { return REFERENCES; }
ROLLBACK    { return ROLLBACK; }
SCHEMA        { return SCHEMA; }
SELECT        { return SELECT; }
SET        { return SET; }
SMALLINT    { return SMALLINT; }
SOME        { return SOME; }
SQLCODE        { return SQLCODE; }
TABLE        { return TABLE; }
TO        { return TO; }
UNION        { return UNION; }
UNIQUE        { return UNIQUE; }
UPDATE        { return UPDATE; }
USER        { return USER; }
VALUES        { return VALUES; }
VIEW        { return VIEW; }
WHENEVER    { return WHENEVER; }
WHERE        { return WHERE; }
WITH        { return WITH; }
WORK        { return WORK; }
X
X    /* punctuation */
X
"="    |
"<>"     |
"<"    |
">"    |
"<="    |
">="        { return COMPARISON; }
X
[-+*/:(),.;]    { return yytext[0]; }
X
X    /* names */
X
[A-Za-z][A-Za-z0-9_]*    { return NAME; }
X
X    /* numbers */
X
[0-9]+    |
[0-9]+"."[0-9]* |
"."[0-9]*    { return INTNUM; }
X
[0-9]+[eE][+-]?[0-9]+    |
[0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
"."[0-9]*[eE][+-]?[0-9]+    { return APPROXNUM; }
X
X    /* strings */
X
'[^'\n]*'    {
X        int c = input();
X
X        unput(c);    /* just peeking */
X        if(c != '\'') {
X            return STRING;
X        } else
X            yymore();
X    }
X
'[^'\n]*$    { yyerror("Unterminated string"); }
X
\n        lineno++;
X
[ \t\r]+    ;    /* white space */
X
"--".*$        ;    /* comment */
X
%%
X
void
yyerror(char *s)
{
X    printf("%d: %s at %s\n", lineno, s, yytext);
}
X
main(int ac, char **av)
{
X    if(ac > 1 && (yyin = fopen(av[1], "r")) == NULL) {
X        perror(av[1]);
X        exit(1);
X    }
X
X    if(!yyparse())
X        printf("SQL parse worked\n");
X    else
X        printf("SQL parse failed\n");
} /* main */
SHAR_EOF
chmod 0664 scn1.l ||
echo 'restore of scn1.l failed'
Wc_c="`wc -c < 'scn1.l'`"
test 3533 -eq "$Wc_c" ||
    echo 'scn1.l: original size 3533, current size' "$Wc_c"
fi
exit 0